// 定义表单删除模块
(function(window, angular, undefined){
	angular.module('form.delete', [])
	.factory('$form_delete', function($rootScope) {
		var $form_delete = {

			// 删除实体
			delEntity : function(fn,row){
				if($rootScope.isOptioning){
					$.messager.alert("系统提示","系统处理中，请稍等！");
					return false;
				}
				$.messager.confirm("操作确认", "确定删除此记录?", function(r){
					if(r){
						var fo = $rootScope[fn];
						var id = row[fo.keyField];
						var url = getServerBaseUrl()+'/'+fo.sn+'/delete/'+id;
						if(fo.rootpath){
							url = fo.rootpath+'/'+fo.sn+'/delete/'+id;
						}
						$rootScope.isOptioning = true;
						$rootScope.deleteEle(url,
							function(data){
								$rootScope.$apply(function() {
									fo.datas.remove(row);
									fo.sRows = [];
									if(fo.datas.length<=0){
										$rootScope.loadData(fn);
									}else{
										fo.rowsCount -= 1;
									}
								});
								$rootScope.isOptioning = false;
							}, 
							function(xhr, status, data){
								var msg = '';
								if(xhr.status<10){
									$.messager.alert('系统提示', '删除失败，请确认网络与认证服务是否正常');
								}else{
									//$.messager.alert('系统提示', '删除失败。系统返回信息 ['+data+']');
									$.messager.alert('系统提示', '删除失败!');
								}
								$rootScope.isOptioning = false;
							}
						);
					}
				});
			},

			// 批量删除实体
			delEntitys : function(fn){
				if($rootScope.isOptioning){
					$.messager.alert("系统提示","系统处理中，请稍等！");
					return false;
				}
				var rows = $rootScope[fn].sRows;
				if(rows==null || rows.length<=0){
					$.messager.alert('系统提示', '请选择要删除的记录！');
					return;
				}
				if(rows.length==1){
					this.delEntity(fn,rows[0]);
				}else{
					this.dels(fn,rows);
				}
			},

			// 内部删除
			dels : function(fn,rows){
				$.messager.confirm("操作确认", "确定删除选择记录?", function(r){
					if(r){
						var fo = $rootScope[fn];
						var values = "";
						rows.forEach(function(e){  
							values += e[fo.keyField] + ",";
						});

						if(values!=""){
							values = values.substr(0, values.length-1);
							var url = getServerBaseUrl()+'/'+fo.sn+'/deletes/'+values;
							$rootScope.isOptioning = true;
							$rootScope.deletes(url,
								function(data){
									$rootScope.$apply(function() {
										rows.forEach(function(e){  
											fo.datas.remove(e);
										});
										if(fo.datas.length<=0){
											$rootScope.loadData(fn);
										}else{
											fo.rowsCount -= rows.length;
										}
									});
									$rootScope.isOptioning = false;
								}, 
								function(xhr, status, data){
									var msg = '';
									if(xhr.status<10){
										$.messager.alert('系统提示', '删除失败，请确认网络与认证服务是否正常');
									}else{
										//$.messager.alert('系统提示', '删除失败。系统返回信息 ['+data+']');
										$.messager.alert('系统提示', '删除失败!');
									}
									$rootScope.isOptioning = false;
								}
							);
						}
						fo.sRows = [];
					}
				});
			}
		};
		for(f in $form_delete){
			$rootScope[f] = $form_delete[f];
		}
		return $form_delete;
	})
	.run(function($rootScope, $form_delete) { });
}(window, angular));
// 定义简单编辑模式
// 1）、就在当前页弹窗编辑
// 2）、编辑页不远程加载，和列表页一起加载
(function(window, angular, undefined){
	angular.module('form.edit.simple', [])
	.factory('$form_edit_simple', function($rootScope) {
		var $form_edit_simple = {

			// 新增记录
			addRow : function(fName,row){
				if(row==null){ row = {}; }
				var fo = $rootScope[fName];
				if(fo.hasOwnProperty("defaultObject")){
					row = jQuery.extend(false, row, fo.defaultObject);
				}
				row[$rootScope.isNew]=true;
				// 处理自动增值键
				var guid = $rootScope.getGUID();
				//row[fo.keyField] = guid;
				
				// 处理随机赋值字段
				if(fo.randomFields){
					for (var i = 0; i < fo.randomFields.length; i++) {
						var randomField = fo.randomFields[i];
						var randomValue = $rootScope.getGUID();
						row[randomField] = randomValue;
					};
				}
				fo.editRow = row;
				return true;
			},

			// 编辑记录 
			editRow : function(fName,row){
				var fo = $rootScope[fName];
				if(row != null){
					var qf = fo.queryFields;
					if(qf==null || qf==''){
						if(fo.ssn != fo.esn){
							// 如果查询服务和编辑服务不一样时，则编辑时重新加载对象
							return $form_edit_simple.editRowByRemote(fName,row);
						}else{
							return $form_edit_simple.editRowByLocal(fName,row);
						}
					}else{
						// 如果设置了查询字段，则编辑时重新加载对象
						return $form_edit_simple.editRowByRemote(fName,row);
					}
				}else{
					$.messager.alert("系统提示","请选择一条要编辑的数据！");
					return false;
				}
			},

			// 编辑记录 
			editRowByLocal : function(fName,row){
				var fo = $rootScope[fName];
				fo.curOldRow = row;
				var copyRow = jQuery.extend(true, {}, row);
				fo.editRow = copyRow;
				return true;
			},

			// 编辑记录 
			editRowByRemote : function(fName,row,callback,onerror){
				var fo = $rootScope[fName];
				fo.editRow = {};
				var id = row[fo.keyField];
				fo.curOldRow = row;
				var url = getServerBaseUrl()+'/'+fo.esn+'/getEntity';
				$rootScope.isOptioning = true;
				$rootScope.getEntity(url,id,function(data){
					$rootScope.isOptioning = false;
					if(!data){
						$rootScope.addRow(fName);
						data = fo.editRow;
					}
					if(callback) callback(fName, data);
					$rootScope.$apply(function() {
						fo.editRow = data;
					});
				},function(){ 
					$rootScope.isOptioning = false;
					if(onerror) onerror(fName);
				});
				return true;
			},
			
			//编辑记录 
			editRowByKey : function(fName,id,callback,onerror){
				var fo = $rootScope[fName];
				fo.editRow = {};
				var url = getServerBaseUrl()+'/'+fo.esn+'/getEntity';
				$rootScope.isOptioning = true;
				$rootScope.getEntity(url,id,function(data){
					$rootScope.isOptioning = false;
					if(!data){
						$rootScope.addRow(fName);
						data = fo.editRow;
					}
					if(callback) callback(fName, data);
					$rootScope.$apply(function() {
						fo.editRow = data;
					});
				},function(){ 
					$rootScope.isOptioning = false;
					if(onerror) onerror(fName);
				});
				return true;
			},
			
			// 保存实体
			save : function(fName,row,callback,onerror){
				var fo = $rootScope[fName];
				if($rootScope.isOptioning){
					$.messager.alert("系统提示","系统处理中，请稍等！");
					return false;
				}
				$rootScope.isOptioning = true;
				
				if(row[$rootScope.isNew]==true){
					var url = getServerBaseUrl()+'/'+fo.esn+'/add';
					if(fo.rootpath){
						url = fo.rootpath+'/'+fo.esn+'/add';
					}
					$rootScope.add(url,row,function(data){
						$rootScope.$apply(function() {
							// 更新row对象
							row = jQuery.extend(true, row, data);
							if(!fo.hasOwnProperty("datas")){
								fo.datas = [];
							}
							if(row.hasOwnProperty($rootScope.isNew)){
								delete row[$rootScope.isNew];
							}
							fo.datas.unshift(row);
							fo.rowsCount += 1;
						});
						$rootScope.isOptioning = false;
						if(callback){
							callback(fName,data);
						}
					}, 
					function(xhr, status, data){
						var msg = '';
						if(xhr.status<10){
							$.messager.alert('系统提示', '保存失败，请确认网络与认证服务是否正常');
						}else{
							//$.messager.alert('系统提示', '保存失败。系统返回信息 ['+data+']');
							$.messager.alert('系统提示', '保存失败!');
						}
						$rootScope.isOptioning = false;
						if(onerror){
							onerror(fName);
						}
					});
				}else{
					var url = getServerBaseUrl()+'/'+fo.esn+'/update';
					if(fo.rootpath){
						url = fo.rootpath+'/'+fo.esn+'/update';
					}
					$rootScope.update(url,row,function(data){
						$rootScope.$apply(function() {
							var or = fo.curOldRow;
							// 清除数组
							for (prop in or) {
					            if(or[prop] instanceof Array ){
					            	delete or[prop];
					            }
					        }
							// 更新对象
							if(or){
								or = jQuery.extend(true, or, data);
							}
						});
						$rootScope.isOptioning = false;
						if(callback){
							callback(fName,data);
						}
					}, 
					function(xhr, status, data){
						var msg = '';
						if(xhr.status<10){
							$.messager.alert('系统提示', '保存失败，请确认网络与认证服务是否正常');
						}else{
							//$.messager.alert('系统提示', '保存失败。系统返回信息 ['+data+']');
							$.messager.alert('系统提示', '保存失败!');
						}
						$rootScope.isOptioning = false;
						if(onerror){
							onerror(fName);
						}
					});
				}
			},
			
			//属性检查
			attributeCheck : function(fName,row,id,name,tacheId,callback,onerror){
				var fo=$rootScope[fName];
				var baseUrl = getServerBaseUrl()+'/checkservice'+'/check';
				//添加用户指定的path
				if(fo.rootpath){
					baseUrl = fo.rootpath+'/checkservice'+'/check';
				}		
				$rootScope.check(baseUrl,row,id,name,tacheId,function(data){
					if(callback) callback(fName, data);
				},function(xhr, status, data){
					var msg = '';
					if(xhr.status<10){
						$.messager.alert('系统提示', '检查失败，请确认网络与认证服务是否正常');
					}else{
						//$.messager.alert('系统提示', '检查失败。系统返回信息 ['+data+']');
						$.messager.alert('系统提示', '检查失败!');
					}
					if(onerror){
						onerror(fName);
					}
				});
			},

			// 表单验证
			formValidate : function(form){
				if(!form){
					return false;
				}
				var info = [];
				var flag = true;
				for(var attr in form){
					if(attr.indexOf("form") == 0){
						if(!form[attr]["$valid"] || !form[attr]["$error"]){
							console.log("不通过项："+attr);
							flag = false;
							info.push("<span style='color:red'>"+$("[name = "+attr+"]").attr("alias")+"<br></span>");
						}
					}
				}
				if(!flag){
					info = info.join("");
					$.messager.alert('系统提示','以下表单项没有填写正确! <br>'+info);
					return false;
				}
				return true;
			}
		};
		for(f in $form_edit_simple){
			$rootScope[f] = $form_edit_simple[f];
		}
		return $form_edit_simple;
	})
	.run(function($rootScope, $form_edit_simple) { });
}(window, angular));
// 定义表单初始化模块
(function(window, angular, undefined){

	angular.module('form.init', [])
	.factory('$form_init', function($rootScope) {
		var $form_init = {
			/**
			 * 对象是否为新对象判断值
			 */
			isNew : "FIELD_ISNEW",

			/**
			* 表单的默认值
			*/
			fNames : [],

			/**
			 * 初始化表单属性
			 * fName : 表单名称
			 * fPara : 表单参数
			 * ds : 数据服务
			 * es : 表单事件
			 */
			formInit : function(fName,fPara,ds){
				if(!fName){
					return false;
				}
				
				var defaultFormPara = {
					// 服务名称，如果为空，则默认为表单名称
					sn : null,
					// 查询服务名称，如果为空，则默认为服务名称
					ssn:null,
					// 编辑服务名称，如果为空，则默认为服务名称
					esn:null,
					/**
					 * 表单的主健，只能为一个，一般为GUID字段
					 */
					keyField : '',
					/**
					 * 表单需要随机赋值的字段
					 */
					randomFields : [],
					/**
					 * 查询字段
					 */
					queryFields : '',
					/**
					 * 新值时的默认值
					 */
					defaultObject : {},
					/**
					 * 默认的查询值
					 */
					defaultQueryObject : {},
					/**
					 * 查询变量
					 */
					queryObject : {},
					 /**
					 * 排序对象
					 */
					orderObject : {},
					/**
					 * 当前数据列表
					 */
					datas : [],
					/**
					 * 当前数据列表选择的行
					 */
					sRows : [],
					/**
					 * 分页大小
					 */
					pageSize : 10,
					/**
					 * 分页索引
					 */
					pageIndex : 1,
					/**
					 * 是否计算列表查询下的总记录数
					 */
					computeRowCounts : true,
					/**
					 * 页数
					 */
					pageCount : 1,
					/**
					 * 分页对象列表(1,2,3)
					 */
					pages: [1],
					/**
					 * 总的条数
					 */
					rowsCount: 0,
					/**
					 * 当前编辑对象
					 */
					editRow : null,
					/**
					 * 当前编辑对象的复制对象，用于解决编辑中的结果处理
					 */
					curOldRow : null,
					/**
					 * 是否将分页数据滚动添加，默认为false
					 */
					addResult : false,
					// 当前表单在视图切换的时候，是否会被注销
					canDestroy:true
				};

				var defaultDataServices = {
					getEntitys:'getEntitys',
					getRowCounts:'getRowCounts',
					getEntity:'getEntity',
					add:'add',
					update:'update',
					deleteEle:'deleteEle',
					deletes:'deletes'
				};

				$rootScope[fName] = jQuery.extend(false, defaultFormPara, fPara);
				var fo = $rootScope[fName];
				if(fo.canDestroy){
					$rootScope.fNames.push(fName);
				}
				fo.sn = fo.sn == null ? fName : fo.sn;
				fo.ssn = fo.ssn == null ? fo.sn : fo.ssn;
				fo.esn = fo.esn == null ? fo.sn : fo.esn;
				var dataServer = jQuery.extend(false, defaultDataServices, ds);
				for(f in dataServer){
					fo[f] = $rootScope[dataServer[f]];
				}
				fo.ds = dataServer;
				return true;
			}
		};
		for(f in $form_init){
			$rootScope[f] = $form_init[f];
		}
		return $form_init;
	})
	.run(function($rootScope, $form_init) { });

}(window, angular));
/**
 * 定义表单查询模块
 */
(function(window, angular, undefined){

	angular.module('form.search', [])
	.factory('$form_search', function($rootScope) {

		var $form_search = {

			// 分页加载数据
			loadData : function(fName,callback,onerror){
				$rootScope[fName].pageIndex=1;
				$rootScope.innderLoadData(fName,callback,onerror);
				$rootScope.setRowCount(fName);
				return true;
			},

			// 加载数据
			innderLoadData : function(fName,callback,onerror){
				var query = jQuery.extend(false, $rootScope[fName].defaultQueryObject, $rootScope[fName].queryObject);
				var baseUrl = getServerBaseUrl()+'/'+$rootScope[fName].ssn+'/getEntitys';
				//添加用户指定的path
				if($rootScope[fName].rootpath){
					baseUrl = $rootScope[fName].rootpath+'/'+$rootScope[fName].ssn+'/getEntitys';
				}
				// 删除查询对象中，值为nullitem的对象
				for(var p in query){
					if(query[p]==='nullItem'){
						delete query[p];
					}
				} 

				$rootScope.isOptioning = true;
				$rootScope[fName].getEntitys(baseUrl, 
					$rootScope[fName].queryFields,
					query,
					$rootScope[fName].orderObject,
					$rootScope[fName].pageSize, 
					$rootScope[fName].pageIndex,
					function(data){
						$rootScope.isOptioning = false;
						$rootScope.$apply(function() {
							if(!data){
								data = [];
							}
							$rootScope[fName].selectedRows=[];
							if($rootScope[fName].addResult){
								data.forEach(function(e){
									$rootScope[fName].datas.push(e);
								});
							}else{
								$rootScope[fName].datas = data;
							}
							if(callback){
								callback(fName,data);
							}
						});
					}, 
					function(){ 
						$rootScope.isOptioning = false;
						if(onerror){
							onerror(fName);
						}
					}
				);
				return true;
			},

			// 计算总记录数
			setRowCount : function(fName){
				if(!$rootScope[fName].computeRowCounts){
					return true;
				}
				var query = jQuery.extend(false, $rootScope[fName].defaultQueryObject, $rootScope[fName].queryObject);
				var url = null;
				//添加用户指定的path
				if($rootScope[fName].rootpath){
					url = $rootScope[fName].rootpath+'/'+$rootScope[fName].ssn+'/getRowCounts';
				}else{
					url = getServerBaseUrl()+'/'+$rootScope[fName].ssn+'/getRowCounts';
				}
				$rootScope.getRowCounts(
					url, query,
					function(data){
						$rootScope.$apply(function() {
							if(!data || data == 0){
								$rootScope[fName].rowsCount = 0;
								$rootScope[fName].pages = [1];
								$rootScope[fName].pageCount=1;
							}else{
								$rootScope[fName].rowsCount = data;
								var pc = parseInt(data / $rootScope[fName].pageSize);
								if(data % $rootScope[fName].pageSize!=0){
									pc++;
								}
								$rootScope[fName].pageCount=pc;
								$rootScope[fName].pages=[];
								//处理掉字段数据量太大导致浏览器崩溃问题
								for(var i=1;i<=pc && i<100;i++){
									$rootScope[fName].pages.push(i);
								}
							}
						});
					}, 
					function(){ }
				);
				return true;
			},

			// 重新设置查询条件
			resetQueryObject : function(fName){
				$rootScope[fName].queryObject={};
				return true;
			},
			
			// 设置查询条件并查询
			setQueryObject : function(fName, field, value){
				if(value==null || value == "null"){
					if($rootScope[fName].queryObject.hasOwnProperty(field)){
						delete $rootScope[fName].queryObject[field];
					}
				}else{
					$rootScope[fName].queryObject[field]=value;
				}
				return true;
			},
			
			// 设置排序对象
			setOrderObject : function(fName, field, value){
				if(value==null || value == "null"){
					if($rootScope[fName].orderObject.hasOwnProperty(field)){
						delete $rootScope[fName].orderObject[field];
					}
				}else{
					$rootScope[fName].orderObject[field]=value;
				}
				return true;
			},
			
			// 设置分页索引并且重新查询数据
			setPageIndex : function(fName, pageIndex){
				if($rootScope.isOptioning){
					$.messager.alert("系统提示","系统处理中，请稍等！");
					return false;
				}
				$rootScope[fName].pageIndex = pageIndex;
				$rootScope.innderLoadData(fName);
				return true;
			},
			
			//上一页
			prePage : function(fName){
				var pageIndex = $rootScope[fName].pageIndex;
				pageIndex--;
				if(pageIndex<=0){
					pageIndex =1 ;
				}
				this.setPageIndex(fName, pageIndex);
			},
			
			//下一页
			nextPage : function(fName){
				var pageIndex = $rootScope[fName].pageIndex;
				var pageCount = $rootScope[fName].pageCount;
				pageIndex++;
				if(pageIndex>pageCount){
					pageIndex = pageCount ;
				}
				this.setPageIndex(fName, pageIndex);
			},
			
			//首页
			firstPage : function(fName){
				this.setPageIndex(fName, 1);
			},
			
			//尾页
			lastPage : function(fName){
				var pageCount = $rootScope[fName].pageCount;
				this.setPageIndex(fName, pageCount);
			}
		};

		for(f in $form_search){
			$rootScope[f] = $form_search[f];
		}
		return $form_search;
	})
	.run(function($rootScope, $form_search) { });

}(window, angular));
// 定义表单列表选择模块
(function(window, angular, undefined){
	
	angular.module('form.selected', [])
	.factory('$form_selected', function($rootScope, $state) {
		var $form_selected = {
			
			// 选择字段属性
			selectedField : "selected",

			// 设置全选 fn表单名称，cn:checked控件名称，field:选择的字段，默认为selectedField
			selectAll : function(fn,cn,field,trueValue,falseValue){
				field = field ? field : $rootScope.selectedField;
				var checked = $("#"+cn).attr("checked") == "checked";
				var checkedValue = null;
				if(checked){
					checkedValue = trueValue ? trueValue : checked;
				}else{
					checkedValue = falseValue ? falseValue : checked;
				}
				$rootScope[fn].sRows = [];
				$rootScope[fn].datas.forEach(function(e){  
				    e[field] = checkedValue;
				    if(checked){
				    	$rootScope[fn].sRows.push(e);
				    }
				});
			},

			// 设置全选 fn表单名称，cn:checked控件名称，field:选择的字段，默认为selectedField
			selectAllByList : function(datas,cn,field,trueValue,falseValue){
				if(!datas) return;
				field = field ? field : $rootScope.selectedField;
				var checked = $("#"+cn).attr("checked") == "checked";
				var checkedValue = null;
				if(checked){
					checkedValue = trueValue ? trueValue : checked;
				}else{
					checkedValue = falseValue ? falseValue : checked;
				}
				datas.forEach(function(e){  
				    e[field] = checkedValue;
				});
			},

			// 选择或取消选择，fn表单名称,row:需选择数据,onlySelect:是否只选择指定数据
			selectRow : function(fn, row, onlySelect){
				var checked = row[$rootScope.selectedField];
				onlySelect = onlySelect ? onlySelect : false;
				$rootScope[fn].sRows = [];
				if(onlySelect){
					$rootScope[fn].datas.forEach(function(e){
						if(row!=e){
							e[$rootScope.selectedField]=false;
						}
					});
					if(checked){
						$rootScope[fn].sRows.push(row);
					}
				}else{
					$rootScope[fn].datas.forEach(function(e){
						if(row!=e 
								&& e.hasOwnProperty($rootScope.selectedField)
								&& e[$rootScope.selectedField]){
							$rootScope[fn].sRows.push(e);
						}
					});
					if(checked){
						$rootScope[fn].sRows.push(row);
					}
				}
			},

			// 选择或取消选择，fn表单名称,row:需选择数据,onlySelect:是否只选择指定数据
			selectRowByList : function(datas, row, onlySelect){
				if(!datas) return;
				var checked = row[$rootScope.selectedField];
				onlySelect = onlySelect ? onlySelect : false;
				if(onlySelect){
					datas.forEach(function(e){
						if(row!=e){
							e[$rootScope.selectedField]=false;
						}
					});
				}
			}
		};
		for(f in $form_selected){
			$rootScope[f] = $form_selected[f];
		}
		return $form_selected;
	})
	.run(function($rootScope, $form_selected) { });
	
}(window, angular));
// 定义简单编辑模式
// 1）、就在当前页弹窗编辑
// 2）、编辑页不远程加载，和列表页一起加载
(function(window, angular, undefined){
	angular.module('form.tree.edit.simple', [])
	.factory('$form_tree_edit_simple', function($rootScope) {
		var $form_tree_edit_simple = {
			// 添加树形记录
			addTreeRow : function(fName,row){
				if(row==null){ row = {}; }
				row[$rootScope[fName].pIDField]=$rootScope[fName].navLastPid;
				return $rootScope.addRow(fName,row);
			}
		};
		for(f in $form_tree_edit_simple){
			$rootScope[f] = $form_tree_edit_simple[f];
		}
		return $form_tree_edit_simple;
	})
	.run(function($rootScope, $form_tree_edit_simple) { });
}(window, angular));
// 定义树型表初始化接口
(function(window, angular, undefined){
	angular.module('form.tree.init', [])
	.factory('$form_tree_init', function($rootScope) {
		var $form_tree_init = {

			// 初始化表单属性
			treeFormInit : function(fName,fPara,ds){
				if(!fName){
					return false;
				}
				// 默认树型表单参数
				var defaultTreeFormPara = {
					// 表单中treeGrid的idField
					idField : 'id',
					// 表单中treeGrid的PIDField
					pIDField : 'pid',
					// 表单中treeGrid的树级别字段
					jBField : 'level',
					// 默认先查询第一级别的数据
					queryObject : {pid:'0'},
					// 树形导航
					treeNavs:[{pid:'0',n:'所有数据',d:{}}],
					// 树形导航的最后PID值
					navLastPid:'0',
					// 树形导航深度
					maxNavs:5
				};
				var afPara = jQuery.extend(false, defaultTreeFormPara, fPara);
				return $rootScope.formInit(fName,afPara,ds);
			}
		};
		for(f in $form_tree_init){
			$rootScope[f] = $form_tree_init[f];
		}
		return $form_tree_init;
	})
	.run(function($rootScope, $form_tree_init) { });
}(window, angular));
// 定义树型表单查询接口
(function(window, angular, undefined){
	angular.module('form.tree.search', [])
	.factory('$form_tree_search', function($rootScope) {
		var $form_tree_search = {
			// 添加树导航
			addNav : function(fn,id,n,r){
				if($rootScope[fn].treeNavs.length>=$rootScope[fn].maxNavs){
					return;
				}
				$rootScope[fn].treeNavs.push({pid:id,n:n,d:r});
				$rootScope[fn].navLastPid = id;

				$rootScope.navLoadData(fn);
				return true;
			},
			// 上一级
			preNav : function(fn){
				if($rootScope[fn].treeNavs.length<=1){
					return true;
				}
				$rootScope[fn].treeNavs.pop();
				$rootScope[fn].navLastPid = $rootScope[fn].treeNavs[$rootScope[fn].treeNavs.length-1].pid;
				$rootScope.navLoadData(fn);
				return true;
			},
			// 索引导航
			indexNav : function(fn,i){
				if(i<0) return true;
				if(i>=$rootScope[fn].treeNavs.length) return true;
				for(var n=$rootScope[fn].treeNavs.length-1;n>i;n--){
					$rootScope[fn].treeNavs.pop();
				}
				$rootScope[fn].navLastPid = $rootScope[fn].treeNavs[$rootScope[fn].treeNavs.length-1].pid;
				$rootScope.navLoadData(fn);
				return true;
			},
			// 内部加载
			navLoadData : function(fn){
				$rootScope[fn].queryObject={};
				$rootScope[fn].queryObject[$rootScope[fn].pIDField]=$rootScope[fn].navLastPid;
				$rootScope[fn].sRows = [];
				$rootScope.loadData(fn);
			},
			treeResetQueryObject : function(fn){
				$rootScope[fn].queryObject={};
				$rootScope[fn].queryObject[$rootScope[fn].pIDField]=$rootScope[fn].navLastPid;
			}
		};
		for(f in $form_tree_search){
			$rootScope[f] = $form_tree_search[f];
		}
		return $form_tree_search;
	})
	.run(function($rootScope, $form_tree_search) { });
}(window, angular));
// 定义简单子表操作接口
(function(window, angular, undefined){
	angular.module('form.child.simple', [])
	.factory('$form_child_simple', function($rootScope) {
		var $form_child_simple = {

			// 在子表本地中添加一行
			addLocalRow : function(editRow,cField,cName){
				var list = editRow[cField];
				if(!list) {
					list = [];
					editRow[cField] = list;
				}

				$rootScope.addRow(cName);
				list.push($rootScope[cName].editRow);
				return true;
			},

			// 在子表本地中删除一行
			delLocalRow : function(list,row){
				$.messager.confirm("操作确认", "确定删除此记录?", function(r){
					if(r){
						$rootScope.$apply(function() {
							list.remove(e);
						});
					}
				});
			},

			// 在子表本地中删除选中行
			delLocalRows : function(list){	
				
				var sRows=[];
				list.forEach(function(e){
					if(e.hasOwnProperty($rootScope.selectedField)
							&& e[$rootScope.selectedField]){
						sRows.push(e);
					}
				});
				sRows.forEach(function(e){
					$.messager.confirm("操作确认", "确定删除此记录?", function(r){
						$rootScope.$apply(function() {
							list.remove(e);
						});
					});
					
				});
			}
		};
		for(f in $form_child_simple){
			$rootScope[f] = $form_child_simple[f];
		}
		return $form_child_simple;
	})
	.run(function($rootScope, $form_child_simple) { });
}(window, angular));
(function(window, angular, undefined){
	angular.module('form.data', [])
	.factory('$form_data', function($rootScope) {
		var $form_data = {
			// 将对象转换为json字符串
			toJSONStr : function(obj) {
				if (typeof obj === 'string')
					return obj;
				if (typeof obj === 'object'){
					if(obj == null)
						return ;
					return JSON.stringify(obj);
				}
				throw new Error('参数必须为对象（数组）或对象（数组）的JSON字符串');
			},
			
			// 数据列表查询
			getEntitys : function(url,fields,where,order,pageSize,pageIndex,callback,onerror) {
				var args = {
					queryFields : fields,
					where : where,
					order : order,
					pageSize : pageSize,
					pageIndex : pageIndex
				};
				args.where = $rootScope.toJSONStr(args.where);
				args.order = $rootScope.toJSONStr(args.order);
				args=$rootScope.toJSONStr(args);
				jQuery.support.cors = true;
				$.ajax({
					url : url,
					type : 'POST',
					data : args,
					timeout : 35000,
					dataType : 'json',
					headers: { 'jwt': $.cookie('jwt') },
					contentType: "application/json;charset=utf-8",
					success : callback,
					error : onerror
				});
			},

			// 数据总记录数查询
			getRowCounts : function(url,where,callback,onerror) {
				var args = { where : where };
				args.where = $rootScope.toJSONStr(args.where);
				args=$rootScope.toJSONStr(args);
				jQuery.support.cors = true;
				$.ajax({
					url : url,
					type : 'POST',
					data : args,
					headers: { 'jwt': $.cookie('jwt') },
					contentType: "application/json;charset=utf-8",
					timeout : 35000,
					dataType : 'json',
					success : callback,
					error : onerror
				});
			},

			getEntity : function(url,id,callback,onerror){
				url+="/"+id;
				jQuery.support.cors = true;
				$.ajax({
					url : url,
					type : 'POST',
					data : null,
					timeout : 35000,
					headers: { 'jwt': $.cookie('jwt') },
					contentType: "application/json;charset=utf-8",
					dataType : 'json',
					success : callback,
					error : onerror
				});
			},

			add : function(url,row,callback,onerror){
				var args = { entity : row };
				args.entity = $rootScope.toJSONStr(args.entity);
				args = $rootScope.toJSONStr(args);
				jQuery.support.cors = true;
				$.ajax({
					url : url,
					type : 'POST',
					data : args,
					timeout : 35000,
					headers: { 'jwt': $.cookie('jwt') },
					contentType: "application/json;charset=utf-8",
					dataType : 'json',
					success : callback,
					error : onerror
				});
			},

			update : function(url,row,callback,onerror){
				var args = { entity : row };
				args.entity = $rootScope.toJSONStr(args.entity);
				args = $rootScope.toJSONStr(args);
				jQuery.support.cors = true;
				$.ajax({
					url : url,
					type : 'POST',
					data : args,
					timeout : 35000,
					headers: { 'jwt': $.cookie('jwt') },
					contentType: "application/json;charset=utf-8",
					dataType : 'json',
					success : callback,
					error : onerror
				});
			},

			deleteEle : function(url,callback,onerror){
				jQuery.support.cors = true;
				$.ajax({
					url : url,
					type : 'DELETE',
					data : null,
					headers: { 'jwt': $.cookie('jwt') },
					timeout : 35000,
					dataType : 'json',
					success : callback,
					error : onerror
				});
			},

			deletes : function(url,callback,onerror){
				jQuery.support.cors = true;
				$.ajax({
					url : url,
					type : 'DELETE',
					data : null,
					timeout : 35000,
					headers: { 'jwt': $.cookie('jwt') },
					dataType : 'json',
					success : callback,
					error : onerror
				});
			},
			
			// 数据列表查询
			check : function(url,row,id,name,tacheId,callback,onerror) {
				var args = {
					entity : row,
					guid : id,
					name : name,
					tacheId : tacheId
				};
				args.entity = $rootScope.toJSONStr(args.entity);
				args=$rootScope.toJSONStr(args);
				jQuery.support.cors = true;
				$.ajax({
					url : url,
					type : 'POST',
					data : args,
					timeout : 35000,
					dataType : 'json',
					headers: { 'jwt': $.cookie('jwt') },
					contentType: "application/json;charset=utf-8",
					success : callback,
					error : onerror
				});
			}
	
		};
		for(f in $form_data){
			$rootScope[f] = $form_data[f];
		}
		return $form_data;
	})
	.run(function($rootScope, $form_data) { });

}(window, angular));
// 定义数据字典模块
(function(window, angular, undefined){
	angular.module('dictionary', [])
	.factory('$dictionary', function($rootScope) {
		var $dictionary = {

			initDictionary : function(fn, para){
				// 默认树型表单参数
				var defaultComboPara = {
					// 字典名称
					dicName : '',
					// 表单中treeGrid的idField
					idField : 'id',
					// 表单中treeGrid的PIDField
					pIDField : 'pid',
					// 表单中treeGrid的树级别字段
					levelField : 'level',
			        // id字段
			        codeField:'id', 
			       	// 显示字段
			       	textField:'display',
			       	// 是否最后一级字段
			       	leafField:'',
			       	// 是否添加空行
			       	addSpace:false,
					// 显示字典中的无效值
					showDicNoValidValue:false,
					// 默认的字典PID值
					pDicId:'0',
					// 树形导航的最后PID值
					navLastPid:'0',
					// 树形导航深度
					maxNavs:5,
					// 导航对象
					treeNavs:[{pid:'0',n:'所有'}]
				};
				var afPara = jQuery.extend(false, defaultComboPara, para);
				return $rootScope.formInit(fn, afPara);
			},

			loadDictionary : function(fn,loadEvent){
				var cf = $rootScope[fn];
				$rootScope.getDictionaryChilds(cf.dicName,cf.pDicId,cf.showDicNoValidValue,
					function(data){
						$rootScope.$apply(function() {
							cf.datas = data;
							if(loadEvent) loadEvent(cf.dicName, data);
						});
					}, 
					function(){}
				);
			},

			// 添加树导航
			addDicNav : function(fn,id,n,r){
				var f = $rootScope[fn];
				if(f.treeNavs.length>=f.maxNavs){
					return true;
				}
				f.treeNavs.push({pid:id,n:n,d:r});
				f.navLastPid = id;

				$rootScope.navDicLoadData(fn);
				return true;
			},
			// 上一级
			preDicNav : function(fn){
				var f = $rootScope[fn];
				if(f.treeNavs.length<=1){
					return true;
				}
				f.treeNavs.pop();
				f.navLastPid = f.treeNavs[f.treeNavs.length-1].pid;
				$rootScope.navDicLoadData(fn);
				return true;
			},
			// 索引导航
			indexDicNav : function(fn,i){
				if(i<0) return true;

				var f = $rootScope[fn];
				if(i>=f.treeNavs.length) return true;
				for(var n=f.treeNavs.length-1;n>i;n--){
					f.treeNavs.pop();
				}
				f.navLastPid = f.treeNavs[f.treeNavs.length-1].pid;
				$rootScope.navDicLoadData(fn);
				return true;
			},
			// 内部加载
			navDicLoadData : function(fn){
				var f = $rootScope[fn];
				$rootScope.getDictionaryChilds(f.dicName,f.navLastPid,f.showDicNoValidValue,
					function(data){
						$rootScope.$apply(function() {
							f.datas = data;
						});
					}, 
					function(){}
				);
			},

			getDictionaryText : function(dicName,id,callback,onerror) {
				var url = getServerBaseUrl()+'/dictionarymanage/getText/'+dicName+'/'+id;
				$.ajax({
					url : url,
					type : 'POST',
					data : null,
					headers: { 'jwt': $.cookie('jwt') },
					timeout : 35000,
					dataType : 'json',
					success : callback,
					error : onerror
				});
			},

			getDictionary : function(dicName,id,callback,onerror) {
				var url = getServerBaseUrl()+'/dictionarymanage/getDictionary/'+dicName+'/'+id;
				$.ajax({
					url : url,
					type : 'POST',
					data : null,
					timeout : 35000,
					headers: { 'jwt': $.cookie('jwt') },
					dataType : 'json',
					success : callback,
					error : onerror
				});
			},

			getDictionaryChilds : function(dicName,id,nv,callback,onerror) {
				var url = getServerBaseUrl()+'/dictionarymanage/getChild/'+dicName+'/'+id+'/'+nv;
				$.ajax({
					url : url,
					type : 'POST',
					data : null,
					timeout : 35000,
					headers: { 'jwt': $.cookie('jwt') },
					dataType : 'json',
					success : callback,
					error : onerror
				});
			},

			getDictionaryChildrens : function(dicName,id,level,nv,callback,onerror) {
				var url = getServerBaseUrl()+'/dictionarymanage/getChildrens/'+dicName+'/'+id+'/'+level+'/'+nv;
				$.ajax({
					url : url,
					type : 'POST',
					data : null,
					timeout : 35000,
					headers: { 'jwt': $.cookie('jwt') },
					dataType : 'json',
					success : callback,
					error : onerror
				});
			}
		};
		for(f in $dictionary){
			$rootScope[f] = $dictionary[f];
		}
		return $dictionary;
	})
	.run(function($rootScope, $dictionary) { });
}(window, angular));
/**
 * 定义gis与mis交互控制
 */
(function(window, angular, undefined){
	
	angular.module('form.router', [])
	// 切换时，注销easyui控件
	.factory('$form_router', function($rootScope,$state) {
		var $form_router = {

			/**
			 * easy ui window窗口的收集器，用于对象删除
			 */
			windows : [],

			/**
			 * easy ui tree
			 */
			trees : [],

			/**
			 * easy ui combotree
			 */
			combotrees : [],

			/**
			 * easy ui combobox
			 */
			comboboxs : [],

			/**
			 * easy ui treegrid
			 */
			treegrids : [],

			/**
			 * easy ui Datebox
			 */
			dateboxs : [],

			// 设置VIEW名称
			setUiView : function(vName,isMIS){
				if(vName == $state.current.name){
					return true;
				}
				$rootScope.destroyForm();
				$rootScope.destroyEasyui();
				$state.go(vName);
				isMIS = isMIS==false ? false : true;
				$rootScope.isMIS = isMIS;
				return true;
			},
			
			// 销毁表单
			destroyForm : function(){
				var nForms=[];
				// 删除当前的表单数据
				if($rootScope.fNames.length>0){
					for(var i=0;i<$rootScope.fNames.length;i++){
						var formName = $rootScope.fNames[i];
						if($rootScope.hasOwnProperty(formName) 
							&& $rootScope[formName].canDestroy){
							delete $rootScope[formName];
						}else if($rootScope.hasOwnProperty(formName) ){
							nForms.push(formName);
						}
					}
				}
				$rootScope.fNames = nForms;
			},

			// easy ui
			destroyEasyui : function(){
				// 销毁easy ui对象
				if(this.windows.length>0){
					for(var i=0;i<this.windows.length;i++){
						try{
							var pw = this.windows[i];
							pw.window("destroy");
						}catch(e){}
					}
				}
				this.windows = [];

				// trees
				if(this.trees.length>0){
					for(var i=0;i<this.trees.length;i++){
						try{
							var pw = this.trees[i];
							pw.tree("destroy");
						}catch(e){}
					}
				}
				this.trees = [];

				// 销毁easy ui对象
				if(this.combotrees.length>0){
					for(var i=0;i<this.combotrees.length;i++){
						try{
							var pw = this.combotrees[i];
							pw.combotree("destroy");
						}catch(e){}
					}
				}
				this.combotrees = [];

				// 销毁easy ui对象
				if(this.comboboxs.length>0){
					for(var i=0;i<this.comboboxs.length;i++){
						try{
							var pw = this.comboboxs[i];
							pw.combobox("destroy");
						}catch(e){}
					}
				}
				this.comboboxs = [];

				// 销毁easy ui对象
				if(this.treegrids.length>0){
					for(var i=0;i<this.treegrids.length;i++){
						try{
							var pw = this.treegrids[i];
							pw.treegrid("destroy");
						}catch(e){}
					}
				}
				this.treegrids = [];

				// 销毁easy ui对象
				if(this.dateboxs.length>0){
					for(var i=0;i<this.dateboxs.length;i++){
						try{
							var pw = this.dateboxs[i];
							pw.datebox("destroy");
						}catch(e){}
					}
				}
				this.dateboxs = [];
			}
		};
		for(f in $form_router){
			$rootScope[f] = $form_router[f];
		}
		return $form_router;
	})
	.run(function($rootScope, $form_router) { });
}(window, angular));
/**
 * 对象属性扩展
 */
(function() {
	
	// 通用方法扩展，forEach方法
	if (!Array.prototype.forEach) {
		Array.prototype.forEach = function(callback, thisArg) {
			var T, k;
			if (this == null) {
				throw new TypeError(" this is null or not defined");
			}
			var O = Object(this);
			var len = O.length >>> 0;
			if ({}.toString.call(callback) != "[object Function]") {
				throw new TypeError(callback + " is not a function");
			}
			if (thisArg) {
				T = thisArg;
			}
			k = 0;
			while (k < len) {
				var kValue;
				if (k in O) {
					kValue = O[k];
					callback.call(T, kValue, k, O);
				}
				k++;
			}
		};
	}

	if (!Array.prototype.removeByValue) {
		Array.prototype.removeByValue = function(val) {
			 for(var i=0; i<this.length; i++) {
			    if(this[i] == val) {
			      	this.splice(i, 1);
			      	break;
			    }
			 }
		}
	}

	//通用方法扩展， indexOf 方法（为支持IE8）
	if (!Array.prototype.indexOf) { 
		Array.prototype.indexOf = function(elt) { 
			var len = this.length >>> 0; 
			var from = Number(arguments[1]) || 0; 
			from = (from < 0) ? Math.ceil(from) : Math.floor(from); 
			if (from < 0) from += len; 
			for (; from < len; from++) { 
				if (from in this && this[from] === elt) return from; 
			}
			return - 1; 
		}; 
	} 
	
	/**
	 * 通用方法扩展，删除数组中的索引项
	 */
	if(!Array.prototype.remove){
		Array.prototype.remove = function(row){
			var dx = this.indexOf(row,0);
			if(isNaN(dx) || dx > this.length){
				return;
			}
			this.splice(dx,1);
		};
	}

	/**
	 * 通用方法扩展，去掉字符的空间
	 */
	String.prototype.trim = function() {
	    return this.replace(/(^\s*)|(\s*$)/g,'');
	};

	String.prototype.startWith=function(str){     
	  	var reg=new RegExp("^"+str);     
	  	return reg.test(this);        
	};

	String.prototype.endWith=function(str){     
	  	var reg=new RegExp(str+"$");     
	  	return reg.test(this);        
	};

}).call(this);

/**
 * 定义表单基础逻辑模块集
 */
(function(window, angular, undefined){
	angular.module('form', ['form.data','form.router','dictionary','form.init','form.search','form.selected','form.delete','form.edit.simple','form.tree.init','form.tree.search','form.tree.edit.simple','form.child.simple'])
	.factory('$form_common', function($rootScope) {
		$form_common = {
			/**
			 * 通用方法扩展，获取cookie方法
			 */
			getCookie : function(sName) { 
			    var aCookie = document.cookie.split(";");
			    var lastMatch = null;
			    for (var i = 0; i < aCookie.length; i++) {
			        var aCrumb = aCookie[i].split("=");
			        if (sName == aCrumb[0].trim()) {
			            lastMatch = aCrumb;
			        }
			    }
			    if (lastMatch) {
			        var v = lastMatch[1];
			        if (v === undefined) return v;
			        return unescape(v);
			    }
			    return null;
			},

			/**
			 * 对比两个对象是否相同
			 */
			objEquals : function(objA, obj){
				if(typeof(obj)=="undefined"||obj==null||typeof(obj)!="object") 
			        return false;
			    if(typeof(objA)=="undefined"||objA==null||typeof(objA)!="object") 
			        return false;
			    if(objA == obj) 
			        return true;
			    
			    if(typeof(obj)=="undefined"||obj==null||typeof(obj)!="object") 
			        return false;
			    var length = 0; var length1=0;
			    for(var ele1 in objA) {
			        length++;
			    }               
			    for(var ele2 in obj) {
			        length1++;
			    }               
			    if(length!=length1) 
			        return false;
			    if(obj.constructor==objA.constructor){
			        for(var ele in objA){
			            if(typeof(objA[ele])=="object") {
			                if(!objA[ele].equals(obj[ele]))
			                    return false;
			            }
			            else if(typeof(objA[ele])=="function"){
			                if(!objA[ele].toString().equals(obj[ele].toString())) 
			                    return false;
			            }
			            else if(objA[ele]!=obj[ele]) 
			                return false;
			        }
			        return true;
			    }
			    return false;
			},

			/**
			 * 获取是否为IE浏览器
			 */
			isIE : function() {  
			    if (!!window.ActiveXObject || "ActiveXObject" in window)  
			        return true;  
			    else  
			        return false;  
			},

			/**
			 * 解析字符串为日期对象date,格式必须为 YYYY-MM-DD，返回NaN
			 * @param dateStringInRange
			 * @returns {Date}
			 */
			 parseISO8601:function(dateStringInRange) {  
			   var isoExp = /^\s*(\d{4})-(\d\d)-(\d\d)\s*$/,  
			       date = new Date(NaN), month,  
			       parts = isoExp.exec(dateStringInRange);  
			  
			   if(parts) {  
			     month = +parts[2];  
			     date.setFullYear(parts[1], month - 1, parts[3]);  
			     if(month != date.getMonth() + 1) {  
			       date.setTime(NaN);  
			     }  
			   }  
			   return date;  
			},
			
			/**
			 * 获取url地址的参数
			 */
			getRequest : function() {
			  var url = location.search; //获取url中"?"符后的字串
			   var theRequest = new Object();
			   if (url.indexOf("?") != -1) {
			      var str = url.substr(1);
			      strs = str.split("&");
			      for(var i = 0; i < strs.length; i ++) {
			         theRequest[strs[i].split("=")[0]]=(strs[i].split("=")[1]);
			      }
			   }
			   return theRequest;
			},

			/**
			 * 获取对象是否为null或未定义
			 */
			isNullOrUndefined : function(thing) {
				if(!thing){
					return true;
				}

				if(thing == null){
					return true;
				}

				if(typeof(thing) == undefined){
					return true;
				}

				return false;
		    },

		    /**
			 * 获取对象是否有对象
			 */
			isHasProperty : function(obj, field) {
				if(!isNullOrUndefined(obj)){
					return obj.hasOwnProperty(field);
				}else{
					return false;
				}
		    },

		    /**
			 * 获取对象是否有对象，并且不为空
			 */
			isHasPropertyAndNoNull : function(obj, field) {
				if(!isNullOrUndefined(obj)){
					if(obj.hasOwnProperty(field)){
						var value = obj[field];
						return !isNullOrUndefined(value);
					}else{
						return false;
					}
				}else{
					return false;
				}
		    },

		    /**
			 * 左部填充
			 */
		    leftPad : function(s, mL, seq) {
				return (Array(mL + 1).join(seq) + s).split('').reverse().join('').substring(0, mL).split('').reverse().join('');
			},

			/**
			 * 获取GUID值
			 */
		    getGUID : function(){
				var a = function(a){
					return 0>a?NaN:30>=a?0|Math.random()*(1<<a):53>=a?(0|1073741824*Math.random())+1073741824*(0|Math.random()*(1<<a-30)):NaN
				};
				var b = function(a,b){
					for(var c=a.toString(16),d=b-c.length,e="0";0<d;d>>>=1,e+=e){
						d&1&&(c=e+c);
					}
					return c;
				};
				var guidString = b(a(32),8)+b(a(16),4)+b(16384|a(12),4)+b(32768|a(14),4)+b(a(48),12);
				return guidString;
			},
			
			/**
			 * 验证是否为数字
			 */
			validateNum : function(num) {
				var reg = new RegExp("^[0-9]*$");
				if (!reg.test(num)) {
					return false;
				}
				return true;
			},

			/**
			 * 当前数是否为双数
			 */
			isDoubleNum : function(num){
				var i = num % 2;
				if(i==0){
					return true;
				}else{
					return false;
				}
			},

			/**
			 * 关闭新开浏览器窗口
			 */
			closeWP : function() {
				var Browser = navigator.appName;
				var indexB = Browser.indexOf('Explorer');

				if (indexB > 0) {
				    var indexV = navigator.userAgent.indexOf('MSIE') + 5;
				    var Version = navigator.userAgent.substring(indexV, indexV + 1);

				    if (Version >= 7) {
				        window.open('', '_self', '');
				        window.close();
				    } else if (Version == 6) {
				        window.opener = null;
				        window.close();
				    } else{
				        window.opener = '';
				        window.close();
				    }
				} else {
				    window.opener=null;
					window.open('', '_self', '');
					window.close();
				}
			},

			//阻止浏览器的默认行为 
			stopDefault :function ( e ) { 
			    //阻止默认浏览器动作(W3C) 
			    if ( e && e.preventDefault ) 
			        e.preventDefault(); 
			    //IE中阻止函数器默认动作的方式 
			    else
			        window.event.returnValue = false; 
			    return false; 
			},

			// 获取对象
			getBinder : function(scope, attrs) {
				if(!attrs) return null;

				return $form_common.getBinderEx(scope.$parent,attrs);
			},

			getBinderEx : function(o, a) {
				if(o==null) return null;

				var props = a.split('.');
				if(props.length==1){
					var i = props[0].indexOf('['); // 处理queryObject['organizationId:like']情况
					if(i>0){
						var ofield = props[0].substring(0,i);
						var ffield = props[0].substring(i+2);
						ffield = ffield.substring(0,ffield.length-2);
						return {obj : o[ofield], field : ffield};
					}else{
						return {obj : o, field : props[0]};
					}
				} else {
					var i = a.indexOf('.');
					a = a.substring(i+1);
					return $form_common.getBinderEx(o[props[0]], a);
				}
			},

			/**
			 * 获取日期对象
			 */
			getDateObject : function(input) {
				if (input == null) {
					return '';
				}
				var dType = typeof(input);
				var date = this.parseData(input,dType);
				
				if(date){ // if(dType=='object')
					var y = date.getFullYear();
					var m = date.getMonth() + 1;
					var d = date.getDate();
					var result = "";
					result = y + '-' + m + '-' + d;
					return result;
				} else if (dType=='string'){ //解决时间显示 ie和chrome不一致问题
					var array = input.match(/\d+/g);  
			    	input = array[0]+'-'+array[1]+'-'+array[2];
			    	return input;
				}
				return '';
			},

			/**
			 * 获取日期对象
			 */
			getTimeObject : function(input) {
				if (input == null) {
					return '';
				}
				var dType = typeof(input);
				var date = this.parseData(input,dType);
				
				if(date){ // if(dType=='object')
					var y = date.getFullYear();
					var m = date.getMonth() + 1;
					var d = date.getDate();
					var result = "";
					result = y + '-' + m + '-' + d + ' ' + date.getHours()+':'+date.getMinutes()+':'+date.getSeconds();
					return result;
				} else if (dType=='string'){ //解决时间显示 ie和chrome不一致问题
					var array = input.match(/\d+/g);  
			    	input = array[0]+'-'+array[1]+'-'+array[2] + ' ' + array[3]+':'+array[4]+':'+array[5];
			    	return input;
				}
				return '';
			},
			
			getChineseDateObject : function(input){
				if (input == null) {
					return '';
				}
				var dType = typeof(input);
				var date = this.parseData(input,dType);
				
				if(date){ // if(dType=='object')
					var y = date.getFullYear();
					var m = date.getMonth() + 1;
					var d = date.getDate();
					var result = "";
					result = y + '年' + m + '月' + d+'日';
					return result;
				} else if (dType=='string'){ //解决时间显示 ie和chrome不一致问题
					var array = input.match(/\d+/g);  
			    	input = array[0]+'年'+array[1]+'月'+array[2]+'日';
			    	return input;
				}
				return '';
			},

			getChineseTimeObject : function(input){
				if (input == null) {
					return '';
				}
				var dType = typeof(input);
				var date = this.parseData(input,dType);
				if(date){
					var m = date.getMonth() + 1;
					var result = date.getFullYear()+'年'+m+'月'+date.getDate()+'日  '+date.getHours()+':'+date.getMinutes()+':'+date.getSeconds();
					return result;
				}else{
					return '';
				}
			},

			parseData : function(input,dType){
				try{
					var date = null;
					if (dType == 'date') {
						date = input;
					} else if (dType == 'object') {
						if (input.hasOwnProperty('time')) {
							date = new Date(input.time);
						} else {
							return null;
						}
					} else if (dType == 'string') {
						//date = new Date(Number(input));
						if(input.indexOf("-")>-1){
							date = new Date(input.replace(/-/,"/"));
						}else{
							date = new Date(Number(input));
						}
					} else if (dType == 'number') {
						date = new Date(input);
					} else if(dType == "undefined"){
						return "";
					}
					return date;
				}catch(e){
					return null;
				}
			},

			/**
			 * 日期格式化
			 */
			formatDate : function(date) {
				if ("" != date) {
					var month = date.getMonth() + 1;
					if (date.getMonth() + 1 < 10) {
						month = '0' + (date.getMonth() + 1);
					}
					var day = date.getDate();
					if (date.getDate() < 10) {
						day = '0' + date.getDate();
					}
					return date.getFullYear() + '-' + month + '-' + day;
				} else {
					return "";
				}
			},

			/**
			 * 日期格式化
			 */
			formatTime : function(date) {
				if ("" != date) {
					var month = date.getMonth() + 1;
					if (date.getMonth() + 1 < 10) {
						month = '0' + (date.getMonth() + 1);
					}
					var day = date.getDate();
					if (date.getDate() < 10) {
						day = '0' + date.getDate();
					}
					return date.getFullYear() + '-' + month + '-' + day + ' ' + date.getHours()+':'+date.getMinutes()+':'+date.getSeconds();;
				} else {
					return "";
				}
			},

			// 查找字典中的项，根据指定字段，指定值
			getArrayItem : function(array,field,value) {
				if(!array) return null;
				var f = null;
				array.forEach(function(item){
					if(item[field]==value) f = item;
				});
				return f;
			},

			nullOrSpace : function(o){
				if(o==undefined || o==null || o==''){
					return true;
				}else{
					return false;
				}
			},

			/**
			 * 设置数据分析合并分割的效果图
			 * @param  {[type]} list  [description]
			 * @param  {[type]} field [description]
			 * @return {[type]}       [description]
			 */
			tableFormate:function(list,field){
				if(list==null || list.length<2) return ;

				var start=0;
				var count=1;

				var cValue=list[0][field];
				for(var k=1;k<list.length;k++){
					var kData=list[k];
					var kValue=kData[field];

					if((kValue==null && cValue==null)
						|| kValue==cValue){
						count++;
						list[k][field+"_count"]=0;
						if(k==list.length-1){
							list[start][field+"_count"]=count;
						}
					}else{
						cValue=kValue;

						list[start][field+"_count"]=count;
						count=1;
						start=k;
						if(k==list.length-1){
							list[k][field+"_count"]=count;
						}
					}
				}
			}

		};
		for(f in $form_common){
			$rootScope[f] = $form_common[f];
		}
		return $form_common;
	})
	.run(function($rootScope, $form_common) { });
}(window, angular));